import { server_bot } from "..";
import sdk from "../core";
import * as fs from 'fs';
import * as path from 'path';

export class autoTest {
    constructor() {
        // 移除构造函数中的自动调用
    }

    private async sendMsg(content: string, userId: string): Promise<void> {
        return new Promise((resolve, reject) => {
            try {
                server_bot.callApi('Message', {
                    UserInfo: {
                        id: '123',
                        name: 'test',
                        isBot: false
                    },
                    Message: {
                        msgId: sdk.tool.common.uuid,
                        userId: userId,
                        private: false,
                        content: content,
                        guildId: '123'
                    },
                    ClientInfo: {
                        id: '123',
                        platform: 'test',
                        name: 'test'
                    }
                });
                
                // 给API调用一些时间来处理消息
                setTimeout(() => {
                    resolve();
                }, 100);
            } catch (error) {
                reject(error);
            }
        });
    }

    // 生成随机userID
    private generateRandomUserId(): string {
        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
    }

    // 等待指定时间
    private async wait(ms: number): Promise<void> {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    // 执行单个测试用例
    private async executeTestCase(testCaseName: string, testCasePath: string) {
        try {
            console.log(`🔎🔎🔎🔎开始测试: ${testCaseName}`);
            
            // 读取测试用例文件
            const content = fs.readFileSync(testCasePath, 'utf-8');
            const messages = content.split('\n').filter(line => line.trim() !== '');
            
            // 为每个测试用例生成随机userID
            const userId = this.generateRandomUserId();
            console.log(`测试用例 ${testCaseName} 使用用户ID: ${userId}`);
            
            // 逐行执行消息，每条消息间隔1秒
            for (let i = 0; i < messages.length; i++) {
                const message = messages[i].trim();
                if (message) {
                    console.log(`执行消息 ${i + 1}/${messages.length}: ${message}`);
                    await this.sendMsg(message, userId);
                    
                    // 如果不是最后一条消息，等待1秒
                    if (i < messages.length - 1) {
                        await this.wait(1000);
                    }
                }
            }
            
            console.log(`🔎🔎🔎🔎测试完成: ${testCaseName}`);
        } catch (error) {
            console.error(`执行测试用例 ${testCaseName} 时出错:`, error);
        }
    }

    async init(testCaseName?: string) {
        try {
            if (testCaseName) {
                console.log(`✅ ✅ ✅ 开始执行指定测试用例: ${testCaseName}`);
            } else {
                console.log('✅ ✅ ✅ 开始初始化自动化测试...');
            }
            
            // 获取tasks目录路径
            const tasksDir = path.join(__dirname, 'tasks');
            
            // 检查tasks目录是否存在
            if (!fs.existsSync(tasksDir)) {
                console.error('tasks目录不存在:', tasksDir);
                return;
            }
            
            // 读取tasks目录中的所有文件
            const files = fs.readdirSync(tasksDir);
            
            if (files.length === 0) {
                console.log('tasks目录中没有找到测试用例文件');
                return;
            }
            
            let targetFiles: string[];
            
            if (testCaseName) {
                // 如果指定了测试用例名称，只测试该文件
                if (files.includes(testCaseName)) {
                    targetFiles = [testCaseName];
                    console.log(`找到指定测试用例: ${testCaseName}`);
                } else {
                    console.error(`未找到指定的测试用例: ${testCaseName}`);
                    console.log('可用的测试用例文件:', files);
                    return;
                }
            } else {
                // 如果没有指定名称，测试所有文件
                targetFiles = files;
                console.log(`找到 ${files.length} 个测试用例文件:`, files);
            }
            
            // 遍历目标测试用例文件
            for (const file of targetFiles) {
                const testCasePath = path.join(tasksDir, file);
                const currentTestCaseName = file; // 文件名就是测试用例名称
                
                // 检查是否为文件（不是目录）
                if (fs.statSync(testCasePath).isFile()) {
                    await this.executeTestCase(currentTestCaseName, testCasePath);
                    
                    // 测试用例之间也等待1秒（如果不是最后一个）
                    if (targetFiles.indexOf(file) < targetFiles.length - 1) {
                        console.log('等待1秒后执行下一个测试用例...');
                        await this.wait(1000);
                    }
                }
            }
            
            if (testCaseName) {
                console.log(`✅ ✅ ✅ 指定测试用例 ${testCaseName} 执行完成！`);
            } else {
                console.log('✅ ✅ ✅ 所有测试用例执行完成！');
            }
        } catch (error) {
            console.error('初始化自动化测试时出错:', error);
        }
    }
}